home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Amiga Collections: Taifun
/
Taifun 079 (1988-11-15)(Ossowski, Stefan)(DE)(PD).zip
/
Taifun 079 (1988-11-15)(Ossowski, Stefan)(DE)(PD).adf
/
GiroMan
/
Sources
/
Giro.c
< prev
next >
Wrap
C/C++ Source or Header
|
1988-08-14
|
41KB
|
2,013 lines
/* Giro.c
-----------------------
SourceCode für GiroMan V3.00
Letzte Änderung am 06.03.1988
*/
#include "Data.h"
/*********************************************************************/
VOID _cli_parse(){}
VOID _wb_parse(){}
/*********************************************************************/
VOID main()
{
VOID Open_Things(),Auswertung();
BOOL Open_Datei(),Load_Index();
Open_Things();
Set_Screen_Title(MAINWIND,WORKTITEL);
if(!(Load_Index() && Open_Datei()))
{
Disk_Fehler(MainWindow);
EndProgramm(99);
}
Auswertung();
EndProgramm(0);
}
/*********************************************************************/
VOID Open_Things()
{
VOID Make_Graphics();
UCOUNT i;
if(!(IntuitionBase = (struct IntuitionBase*)
OpenLibrary("intuition.library",NULL))) EndProgramm(10);
if(!(GfxBase = (struct GfxBase*)
OpenLibrary("graphics.library",NULL))) EndProgramm(11);
if(AvailMem(MEMF_CHIP)<50000L || AvailMem(MEMF_PUBLIC)<75000L) EndProgramm(30);
if(!(UndoBuffer=(STRPTR)AllocMem( 50L,MEMF_PUBLIC|MEMF_CLEAR))) EndProgramm(31);
if(!(TempText = (STRPTR)AllocMem( 50L,MEMF_PUBLIC|MEMF_CLEAR))) EndProgramm(32);
if(!(TempTextGr=(STRPTR)AllocMem(100L,MEMF_PUBLIC|MEMF_CLEAR))) EndProgramm(33);
for(i=0;i<3;i++)
{
if(!(EingabeBuffer[i]=
(STRPTR)AllocMem(34L,MEMF_PUBLIC|MEMF_CLEAR))) EndProgramm(34);
EinGadInfo[i].Buffer=EingabeBuffer[i];
EinGadInfo[i].UndoBuffer=UndoBuffer;
}
for(i=0;i<3;i++)
{
if(!(SuchBuffer[i]=
(STRPTR)AllocMem(34L,MEMF_PUBLIC|MEMF_CLEAR))) EndProgramm(35);
SuchInfo[i].Buffer=SuchBuffer[i];
SuchInfo[i].UndoBuffer=UndoBuffer;
}
for(i=0;i<3;i++)
{
if(!(MonatBuffer[i]=
(STRPTR)AllocMem(34L,MEMF_PUBLIC|MEMF_CLEAR))) EndProgramm(36);
MonatInfo[i].Buffer=MonatBuffer[i];
MonatInfo[i].UndoBuffer=UndoBuffer;
}
if(!(Window1.Screen = (MainScreen = (struct Screen*)
OpenScreen(&Screen1)))) EndProgramm(12);
if(!(MainWindow = (struct Window*)
OpenWindow(&Window1))) EndProgramm(13);
Make_Graphics();
Off_Str_Gadgets();
return;
}
/*********************************************************************/
VOID Make_Graphics()
{
Main_rp= MainWindow->RPort;
Main_vp= &MainScreen->ViewPort;
SetRGB4(Main_vp,GREY,13L,13L,14L); /* Farbe 0 = hellgrau */
SetRGB4(Main_vp,BLACK,1L,1L,1L); /* Farbe 1 = schwarz */
SetRGB4(Main_vp,RED,12L,1L,0L); /* Farbe 2 = rot */
SetRGB4(Main_vp,BLUE, 0L,0L,9L); /* Farbe 3 = blau */
SetAPen(Main_rp,BLUE);
SetBPen(Main_rp,GREY);
SetDrMd(Main_rp,JAM2);
SetMenuStrip(MainWindow,&Menu1);
Menu_Normal(AN);
Menu_Saven(AUS);
PolyDraw(Main_rp,30L,Umrandungen);
return;
}
/*********************************************************************/
BOOL Load_Index()
{
BOOL Ok = FALSE;
if(!(Index=AllocMem(INDEXLENG,MEMF_CLEAR))) EndProgramm(30);
if((DateiIndex=Open(IndexName,MODE_OLDFILE))
&&(Read(DateiIndex,Index,INDEXLENG) != DISKERROR))
Ok =TRUE;
if(DateiIndex)
Close(DateiIndex);
DateiIndex = NULL;
return(Ok);
}
/*********************************************************************/
BOOL Open_Datei()
{
BOOL Ok = FALSE;
if(!(Eintrag=AllocMem(SIZEEINTRAG*20,MEMF_PUBLIC|MEMF_CLEAR))) EndProgramm(31);
if((HauptDatei=Open(DateiName,MODE_READWRITE))
&&(Seek(HauptDatei,-8L,OFFSET_END) != DISKERROR)
&&(Read(HauptDatei,&DatenAkt,2L) != DISKERROR)
&&(Read(HauptDatei,&AltSaldo,4L) != DISKERROR)
&&(Read(HauptDatei,&NeuVergeben,2L) !=DISKERROR))
{
Ok = TRUE;
Geaendert = FALSE;
NeuSaldo = AltSaldo;
NeuDatenAkt = DatenAkt;
AktIndex = Index+DATENMAX;
MaxIndex = AktIndex-19;
PrintIText(Main_rp,&Ueber[2],0L,0L);
Print(Main_rp,BetrInAsc(AltSaldo),TAB(AltSaldo),240L,FAR(AltSaldo));
PrintNeuSaldo();
PrintUntereSeite();
}
return(Ok);
}
/*********************************************************************/
VOID Auswertung()
{
VOID WelchesGadget();
BOOL Menu();
VOID Abfrage_Maus();
BOOL Ende = FALSE;
while (Ende == FALSE)
{
IDCMP_Abfrage(MainWindow);
switch (MessClass)
{
case GADGETDOWN:
case GADGETUP:
WelchesGadget();
break;
case MENUPICK:
Ende = Menu();
break;
case MOUSEBUTTONS:
Abfrage_Maus();
break;
}
}
return;
}
/*********************************************************************/
VOID WelchesGadget()
{
VOID Move_Slider();
switch (GadID)
{
case 1:
Move_Slider();
break;
case 2:
PrintNachOben();
break;
case 3:
PrintNachUnten();
break;
}
return;
}
/*********************************************************************/
VOID Move_Slider()
{
INDEX *IN;
INDEX *min = Index+DATENMAX-NeuDatenAkt;
BOOL Direkt = (MessClass != GADGETUP) ? TRUE : FALSE;
do
{
if(Direkt)
{
if((Message=(struct IntuiMessage*)
GetMsg(MainWindow->UserPort))!=NULL)
{
MessClass = Message->Class;
ReplyMsg(Message);
}
}
IN = min+((Slider.VertPot/NeuProp)*20);
if(IN > MaxIndex) IN = MaxIndex;
Setz_VonBis(IN);
}
while(MessClass != GADGETUP);
if(IN != AktIndex)
{
if(IN > AktIndex)
{
if(Direkt) AktIndex = IN-20;
PrintNachUnten();
}
else
{
if(Direkt) AktIndex = IN+20;
PrintNachOben();
}
}
return;
}
/*********************************************************************/
BOOL Menu()
{
VOID Hinzu_Fuegen();
VOID Aendere_Eintrag();
VOID Loesche_Eintrag();
VOID Suchen();
VOID Neue_Datei();
VOID Neues_Saldo();
VOID Finde_Datum();
VOID Saldo_Suchen();
VOID Drucken();
VOID Monats_Daten();
VOID Monat_Hinzu();
BOOL Save_All();
BOOL Ende=FALSE;
if(MENUNUM(MessCode) != MENUNULL)
switch(MENUNUM(MessCode))
{
case 0: /* PROGRAMM */
switch(ITEMNUM(MessCode))
{
case 0: /* Beenden */
if(Geaendert)
{
if(Abfr_ReqGr(MainWindow,&ReqText[2],
&ReqGad2,NULL))
if(!(Ende = Save_All()))
Disk_Fehler(MainWindow);
}
else
{
Ende = TRUE;
}
break;
case 1:
Abfr_ReqGr(MainWindow,&ReqText[30],&ReqGad1,NULL);
break;
}
break;
case 1: /* GIRODATEN */
switch(ITEMNUM(MessCode))
{
case 0:
Hinzu_Fuegen();
break;
case 1:
Suchen();
break;
case 2:
if(!(Save_All()))
Disk_Fehler(MainWindow);
break;
}
break;
case 2: /* EDITIEREN */
switch (ITEMNUM(MessCode))
{
case 0:
Drucken();
break;
case 1:
Saldo_Suchen();
break;
case 2:
Aendere_Eintrag();
break;
case 3:
Loesche_Eintrag();
break;
}
break;
case 3: /* Anzeige */
switch (ITEMNUM(MessCode))
{
case 0:
if(AktIndex != (Index+DATENMAX-NeuDatenAkt))
{
AktIndex = Index + 20;
PrintNachOben();
}
else Beep(MainScreen);
break;
case 1:
if(AktIndex != MaxIndex)
{
AktIndex = MaxIndex - 1;
PrintNachUnten();
}
else Beep(MainScreen);
break;
case 2:
if(Abfr_ReqGr(MainWindow,&ReqText[6],
&SuchGadget[0],&SuchGadget[0]))
{
Finde_Datum(SuchBuffer[0]);
AktIndex -= 20;
PrintNachUnten();
}
break;
}
break;
case 4:
switch (ITEMNUM(MessCode))
{
case 0:
Neue_Datei();
break;
case 1:
Neues_Saldo();
break;
}
break;
case 5: /* MONATSDATEN */
switch (ITEMNUM(MessCode))
{
case 0:
Monat_Hinzu();
break;
case 1:
Monats_Daten();
break;
}
break;
}
return(Ende);
}
/*********************************************************************/
VOID Abfrage_Maus()
{
SHORT Aktiviere_Zeile();
if(MessCode != SELECTUP)
if(!(MainWindow->MouseY > 212
|| MainWindow->MouseY < 33
|| MainWindow->MouseX > 610))
AktiveZeile = Aktiviere_Zeile((MainWindow->MouseY-33)/9);
return;
}
/*********************************************************************/
VOID IDCMP_Abfrage(Window)
struct Window *Window;
{
struct Gadget *Gadget;
GadID = 0;
Wait(1L<<Window->UserPort->mp_SigBit);
while((Message = (struct IntuiMessage*)
GetMsg(Window->UserPort)) != NULL)
{
MessClass = Message->Class;
MessCode = Message->Code;
if((MessClass == GADGETUP) || (MessClass == GADGETDOWN))
{
Gadget = (struct Gadget*) Message->IAddress;
GadID = Gadget->GadgetID;
}
ReplyMsg(Message);
}
return;
}
/*********************************************************************/
VOID Hinzu_Fuegen()
{
VOID Loesch_Str_Gadgets();
BOOL Abfrage_EingabeSchluss();
BOOL EingabeSchluss = FALSE;
USHORT No = NeuDatenAkt;
On_Str_Gadgets();
ActivateGadget(&EingabeGadget[0],MainWindow,NULL);
while(EingabeSchluss == FALSE)
{
if(NeuDatenAkt < DATENMAX)
{
IDCMP_Abfrage(MainWindow);
if(MessClass == GADGETUP)
{
switch(GadID)
{
case 10:
EingabeSchluss = Abfrage_EingabeSchluss(0);
break;
case 11:
EingabeSchluss = Abfrage_EingabeSchluss(1);
break;
case 12:
EingabeSchluss = Abfrage_EingabeSchluss(2);
break;
}
}
}
else
{
Abfr_ReqGr(MainWindow,&ReqText[5],&ReqGad1,NULL);
EingabeSchluss = TRUE;
}
}
Loesch_Str_Gadgets();
Off_Str_Gadgets();
if(No != NeuDatenAkt)
{
Menu_Saven(AN);
Print_And_Sort();
}
return;
}
/*********************************************************************/
VOID Suchen()
{
VOID Zeichne_Border();
INDEX *IN = AktIndex;
BOOL StopSuche = FALSE;
BOOL Gefunden = FALSE;
BOOL Printed;
UCOUNT jr,ir;
USHORT Laenge;
STRPTR Help;
if((!(Abfr_ReqGr(MainWindow,NULL,&SuchGadget[1],&SuchGadget[0])))
||(*(SuchBuffer[1]) == '\0'))
return;
Laenge = strlen(SuchBuffer[1]);
Finde_Datum(SuchBuffer[0]);
AktIndex -= 20;
do
{
if((AktIndex += 20) > MaxIndex) AktIndex = MaxIndex;
Set_Screen_Title(MAINWIND,WORKTITEL);
Lade_Seite(AktIndex);
Printed = FALSE;
for(jr=0;(jr<20) && (StopSuche==FALSE);jr++)
{
Help=(STRPTR)(Eintrag+jr);
for(ir=0;ir<34-Laenge;ir++)
{
if(!(strncmp((Help+ir),SuchBuffer[1],Laenge)))
{
if(Printed == FALSE)
{
Printed = TRUE;
IN = AktIndex;
Print_Seite();
}
Zeichne_Border(jr,(UBYTE)RED);
Set_Screen_Title(MAINWIND,MAINTITEL);
if(Gefunden == FALSE)
{
Gefunden = TRUE;
Request(&RequesterKl,MainWindow);
}
do
IDCMP_Abfrage(MainWindow);
while(GadID != 20 && GadID != 21);
StopSuche = (GadID == 21) ? TRUE : FALSE;
Zeichne_Border(jr,(UBYTE)GREY);
break;
}
}
}
}
while((MaxIndex>AktIndex) && (StopSuche==FALSE));
if(Gefunden == TRUE) EndRequest(&RequesterKl,MainWindow);
Set_Screen_Title(MAINWIND,MAINTITEL);
Beep(MainScreen);
AktIndex = IN;
return;
}
/*********************************************************************/
VOID Drucken()
{
SHORT Aktiviere_Zeile();
INDEX *AbIn = AktIndex+AktiveZeile;
INDEX *BisIn;
INDEX *MaxIn = MaxIndex+19;
INDEX *Lauf;
ULONG BisDatum;
USHORT ZeilenMax;
USHORT ZeilenAkt;
FLOAT Gesamt = NeuSaldo;
FLOAT Einzel;
DruckerIO *DruckIO;
Aktiviere_Zeile(AktiveZeile);
if(Abfr_ReqGr(MainWindow,NULL,&FanfoGad,&BisDatGadget))
{
Set_Screen_Title(MAINWIND,WORKTITEL);
BisDatum = DatInLong(SuchBuffer[0]);
if((BisDatum < MINDATUM)
|| (BisDatum > MAXDATUM)
|| (BisDatum <= AbIn->Datum)
|| ((MaxIndex+19)->Datum == BisDatum))
BisIn = MaxIn;
else
for(BisIn=AbIn;BisIn->Datum <= BisDatum;BisIn++);
for(Lauf=AktIndex+AktiveZeile;Lauf<=MaxIn;++Lauf)
{
if((Seek(HauptDatei,(SIZEEINTRAG*Lauf->Nummer)+34L,
OFFSET_BEGINNING) != DISKERROR)
&& (Read(HauptDatei,&Einzel,4L) != DISKERROR))
Gesamt-=Einzel;
else
{
Gesamt = 0.0;
break;
}
}
if(Abfr_ReqGr(MainWindow,&ReqText[18],&ReqGad2,NULL))
{
if((DruckIO = DruckerOnOff(ON)) != NULL)
{
DruckString(DruckIO,(STRPTR)"\0");
DruckCom(DruckIO,aSLRM,5L,75L,0L,0L);
if(DraftGad.Flags & SELECTED)
DruckCom(DruckIO,aDEN2,0L,0L,0L,0L);
DruckString(DruckIO,DruckUber);
ZeilenMax=(FanfoGad.Flags & SELECTED) ? EINZELSIZE : ENDLOSSIZE;
for(ZeilenAkt=4; AbIn<=BisIn ;AbIn++,ZeilenAkt++)
{
if(!((Seek(HauptDatei,(SIZEEINTRAG*AbIn->Nummer),
OFFSET_BEGINNING) != DISKERROR)
&& (Read(HauptDatei,EingabeBuffer[1],34L) != DISKERROR)
&& (Read(HauptDatei,&Einzel,4L) != DISKERROR)))
{
Disk_Fehler(MainWindow);
break;
}
Gesamt+=Einzel;
sprintf(TempTextGr,"%s %-33s %9.2f %9.2f\n",
DatInAsc(AbIn->Datum),EingabeBuffer[1],Einzel,Gesamt);
DruckString(DruckIO,TempTextGr);
if(ZeilenAkt == ZeilenMax)
{
if(ZeilenMax == EINZELSIZE)
if(!(Abfr_ReqGr(MainWindow,&ReqText[18],&ReqGad2,NULL)))
break;
DruckString(DruckIO,DruckUber);
ZeilenAkt = 3;
}
}
DruckString(DruckIO,(STRPTR)"\f");
DruckCom(DruckIO,aRIN,0L,0L,0L,0L);
DruckerOnOff(OFF);
}
else
{
Abfr_ReqGr(MainWindow,&ReqText[19],&ReqGad1,NULL);
}
}
Set_Screen_Title(MAINWIND,MAINTITEL);
}
return;
}
/*********************************************************************/
VOID Saldo_Suchen()
{
SHORT Aktiviere_Zeile();
BOOL Ok = TRUE;
INDEX *MaxIn = MaxIndex+19;
INDEX *Lauf;
FLOAT Gesamt = NeuSaldo;
FLOAT Einzel;
Set_Screen_Title(MAINWIND,WORKTITEL);
for(Lauf=AktIndex+AktiveZeile+1;Lauf<=MaxIn;++Lauf)
{
if((Seek(HauptDatei,(SIZEEINTRAG*Lauf->Nummer)+34L,
OFFSET_BEGINNING) != DISKERROR)
&& (Read(HauptDatei,&Einzel,4L) != DISKERROR))
{
Gesamt-=Einzel;
}
else
{
Ok = FALSE;
break;
}
}
Set_Screen_Title(MAINWIND,MAINTITEL);
if(Ok)
{
sprintf(TempText,"%.2f DM.",Gesamt);
ReqText[16].LeftEdge = (390-(strlen(TempText)*8))/2;
ReqText[16].IText = TempText;
Abfr_ReqGr(MainWindow,&ReqText[16],&ReqGad1,NULL);
}
else
{
Disk_Fehler(MainWindow);
}
Aktiviere_Zeile(AktiveZeile);
return;
}
/*********************************************************************/
VOID Aendere_Eintrag()
{
VOID EingabeDaten_Auswertung();
VOID Loesch_Str_Gadgets();
SHORT Aktiviere_Zeile();
FLOAT saldo;
On_Str_Gadgets();
strcpy(EingabeBuffer[0],DatInAsc((AktIndex+AktiveZeile)->Datum));
strcpy(EingabeBuffer[1],Eintrag+AktiveZeile);
strcpy(EingabeBuffer[2],BetrInAsc((Eintrag+AktiveZeile)->Betrag));
NeuSaldo -= (saldo = (Eintrag+AktiveZeile)->Betrag);
RefreshGadgets(MainWindow->FirstGadget,MainWindow,NULL);
ActivateGadget(EingabeGadget,MainWindow,NULL);
while(!((MessClass == GADGETUP) && (GadID == 12)))
{
IDCMP_Abfrage(MainWindow);
if((GadID == 10) || (GadID == 11))
ActivateGadget(&EingabeGadget[GadID-9],MainWindow,NULL);
}
Off_Str_Gadgets();
Aktiviere_Zeile(AktiveZeile);
if(strcmp(EingabeBuffer[0],DatInAsc((AktIndex+AktiveZeile)->Datum))
||(strcmp(EingabeBuffer[1],Eintrag+AktiveZeile))
||(strcmp(EingabeBuffer[2],BetrInAsc(saldo))))
{
EingabeDaten_Auswertung(AktIndex+AktiveZeile,0);
Menu_Saven(AN);
Print_And_Sort();
}
else
{
NeuSaldo += saldo;
Beep(MainScreen);
Loesch_Str_Gadgets();
}
return;
}
/*********************************************************************/
VOID Loesche_Eintrag()
{
if(NeuDatenAkt >20)
{
if(Abfr_ReqGr(MainWindow,&ReqText[3],&ReqGad2,NULL))
{
(AktIndex+AktiveZeile)->Datum = 1L;
NeuSaldo -= (Eintrag+AktiveZeile)->Betrag;
--NeuDatenAkt;
Aktiviere_Zeile(AktiveZeile);
PrintNeuSaldo();
Print_And_Sort();
Menu_Saven(AN);
Geaendert = TRUE;
}
}
else
{
Beep(MainScreen);
}
return;
}
/*********************************************************************/
VOID Neue_Datei()
{
BOOL Open_Datei();
BOOL Load_Index();
BOOL Ok = FALSE;
INDEX *IND = NULL;
EINTRAG *EIN = NULL;
STRPTR TempInText = NULL;
STRPTR TempDaText = NULL;
UCOUNT ir;
USHORT Minimum = 19;
USHORT AbIndex = DATENMAX-Minimum;
static TEXT HaAlt[] = "HaDat";
static TEXT InAlt[] = "InDat";
struct FileHandle *IndexTemp = NULL;
struct FileHandle *DateiTemp = NULL;
if(!(Abfr_ReqGr(MainWindow,&ReqText[10],&ReqGad2,NULL)))
return;
while(Geaendert == TRUE)
{
if(!(Save_All()))
{
Disk_Fehler(MainWindow);
if(!(Abfr_ReqGr(MainWindow,&ReqText[11],&ReqGad2,NULL)))
return;
}
}
if(!((IND=(INDEX*)AllocMem(INDEXLENG,MEMF_PUBLIC|MEMF_CLEAR)))
||(!(EIN=(EINTRAG*)AllocMem(SIZEEINTRAG*20,MEMF_PUBLIC|MEMF_CLEAR)))
||(!(TempInText=(STRPTR)AllocMem(30L,MEMF_PUBLIC|MEMF_CLEAR)))
||(!(TempDaText=(STRPTR)AllocMem(30L,MEMF_PUBLIC|MEMF_CLEAR))))
{
if(IND)
FreeMem(IND,INDEXLENG);
if(EIN)
FreeMem(EIN,SIZEEINTRAG*20);
if(TempInText)
FreeMem(TempInText,30L);
Abfr_ReqGr(MainWindow,&ReqText[13],&ReqGad1,NULL);
return;
}
if(AktIndex != MaxIndex) PrintUntereSeite();
Set_Screen_Title(MAINWIND,WORKTITEL);
for(ir=0;ir<20;ir++,AbIndex++)
{
(IND+AbIndex)->Datum = (Index+AbIndex)->Datum;
(IND+AbIndex)->Nummer = ir;
strcpy((EIN+ir),(Eintrag+ir));
(EIN+ir)->Betrag = (Eintrag+ir)->Betrag;
}
sprintf(TempInText,"%s-%s",IndexName,Datum());
sprintf(TempDaText,"%s-%s",DateiName,Datum());
if((IndexTemp=Open(TempInText,MODE_NEWFILE))
&&(Write(IndexTemp,IND,INDEXLENG) != DISKERROR))
{
Close(IndexTemp);
if((DateiTemp=Open(TempDaText,MODE_NEWFILE))
&&(Write(DateiTemp,EIN,(LONG)SIZEEINTRAG*20) != DISKERROR)
&&(Write(DateiTemp,&Minimum,2L) != DISKERROR)
&&(Write(DateiTemp,&NeuSaldo,4L) != DISKERROR)
&&(Write(DateiTemp,&Minimum,2L) != DISKERROR))
{
Close(DateiTemp);
Close(HauptDatei);
HauptDatei=NULL;
if((Rename(DateiName,HaAlt))
&&(Rename(IndexName,InAlt))
&&(Rename(TempDaText,DateiName))
&&(Rename(TempInText,IndexName))
&&(Rename(HaAlt,TempDaText))
&&(Rename(InAlt,TempInText))
&&(SetProtection(TempDaText,5L))
&&(SetProtection(TempInText,5L)))
Ok = TRUE;
}
}
if(!(Ok))
{
if(HauptDatei)
Close(HauptDatei);
if(IndexTemp)
Close(IndexTemp);
if(DateiTemp)
Close(DateiTemp);
HauptDatei=NULL;
Disk_Fehler(MainWindow);
}
FreeMem(IND,INDEXLENG);
FreeMem(Index,INDEXLENG);
FreeMem(EIN,SIZEEINTRAG*20);
FreeMem(Eintrag,SIZEEINTRAG*20);
FreeMem(TempInText,30L);
FreeMem(TempDaText,30L);
if(!(Load_Index() && Open_Datei()))
Disk_Fehler(MainWindow);
return;
}
/*********************************************************************/
VOID Neues_Saldo()
{
FLOAT saldo;
if((Abfr_ReqGr(MainWindow,&ReqText[14],&NeuSalGad,&NeuSalGad))
&&(*(SuchBuffer[2]) != '\0')
&&((saldo = (FLOAT)atof(SuchBuffer[2])) <= MAXFLOAT)
&&(saldo >= MINFLOAT))
{
NeuSaldo = saldo;
PrintNeuSaldo();
}
return;
}
/*********************************************************************/
VOID Monats_Daten()
{
VOID End_Monat();
VOID Mon_Auswert();
VOID Print_Monat();
BOOL Open_MonGraphs();
BOOL Open_MonatDat();
if(Open_MonGraphs())
if(Open_MonatDat())
{
Print_Monat(AktMonat);
Mon_Auswert();
}
End_Monat();
return;
}
/*********************************************************************/
VOID Monat_Hinzu()
{
VOID EingabeDaten_Auswertung();
LONG Mon;
UCOUNT i = 0;
struct FileHandle *MonatDatei = (struct FileHandle *) NULL;
*(SuchBuffer[0]) = '\0';
if(!(Monat = (MONAT *)AllocMem(MONATLENG,MEMF_CLEAR|MEMF_PUBLIC)))
Abfr_ReqGr(MainWindow,&ReqText[13],&ReqGad1,NULL);
else
{
if(Abfr_ReqGr(MainWindow,&ReqText[25],&SuchGadget[0],&SuchGadget[0]))
{
Set_Screen_Title(MAINWIND,WORKTITEL);
if((Mon = atol(SuchBuffer[0]+3)) < 1L || Mon > 12L)
Mon = atol(Datum()+3);
if(!((MonatDatei = Open(MonatName,MODE_READWRITE))
&&(Seek(MonatDatei,(Mon-1L)*MONATLENG,OFFSET_BEGINNING) != DISKERROR)
&&(Read(MonatDatei,Monat,MONATLENG) != DISKERROR)))
Disk_Fehler(MainWindow);
else
{
while((*((Monat+i)->Bezeichnung) != '\0') && (i < MONEINT))
{
strcpy(EingabeBuffer[0],SuchBuffer[0]);
strcpy(EingabeBuffer[1],(Monat+i)->Bezeichnung);
strcpy(EingabeBuffer[2],BetrInAsc((Monat+i)->Betrag));
EingabeDaten_Auswertung(Index+DATENMAX-(++NeuDatenAkt),1);
i++;
}
Menu_Saven(AN);
Print_And_Sort();
}
if(MonatDatei)
Close(MonatDatei);
FreeMem(Monat,MONATLENG);
Set_Screen_Title(MAINWIND,MAINTITEL);
*(SuchBuffer[0]) = '\0';
}
}
return;
}
/*********************************************************************/
/*********************************************************************/
BOOL Save_All()
{
BOOL Ok=FALSE;
Set_Screen_Title(MAINWIND,WORKTITEL);
if((DateiIndex=Open(IndexName,MODE_NEWFILE))
&&(Write(DateiIndex,Index,INDEXLENG) != DISKERROR)
&&(Seek(HauptDatei,NULL,OFFSET_END) != DISKERROR)
&&(Write(HauptDatei,(USHORT*)&NeuDatenAkt,2L) != DISKERROR)
&&(Write(HauptDatei,(FLOAT*)&NeuSaldo,4L) != DISKERROR)
&&(Write(HauptDatei,(USHORT*)&NeuVergeben,2L) != DISKERROR))
{
Menu_Saven(AUS);
Geaendert = FALSE;
DatenAkt = NeuDatenAkt;
Ok=TRUE;
}
if(DateiIndex)
Close(DateiIndex);
DateiIndex = NULL;
Set_Screen_Title(MAINWIND,MAINTITEL);
return(Ok);
}
/*********************************************************************/
BOOL Abfr_ReqGr(Window,ReqText,ReqGadget,ActGadget)
struct Window *Window;
struct IntuiText *ReqText;
struct Gadget *ReqGadget;
struct Gadget *ActGadget;
{
BOOL AbfrSchluss;
BOOL Erfolg;
RequesterGr.ReqGadget = ReqGadget;
RequesterGr.ReqText = ReqText;
if(Request(&RequesterGr,Window))
{
Delay(5L);
AbfrSchluss = Erfolg = FALSE;
if(ActGadget)
ActivateGadget(ActGadget,Window,&RequesterGr);
do
{
IDCMP_Abfrage(Window);
switch(GadID)
{
case 13:
if(ReqGadget==&SuchGadget[1])
{
ActivateGadget(ReqGadget,
Window,&RequesterGr);
break;
}
AbfrSchluss = Erfolg = TRUE;
break;
case 14:
case 15:
case 20:
case 39:
AbfrSchluss = Erfolg = TRUE;
break;
case 21:
AbfrSchluss = TRUE;
break;
case 37:
if(ReqGadget == &MonStrGad[2])
ActivateGadget(&MonStrGad[1],
Window,&RequesterGr);
break;
case 38:
ActivateGadget(&MonStrGad[2],Window,&RequesterGr);
break;
}
}
while(AbfrSchluss == FALSE);
EndRequest(&RequesterGr,Window);
}
return(Erfolg);
}
/*********************************************************************/
BOOL Abfrage_EingabeSchluss(Nummer)
USHORT Nummer;
{
VOID EingabeDaten_Auswertung();
BOOL EingabeSchluss;
EingabeSchluss = *(EingabeBuffer[Nummer]) == '\0' ? TRUE : FALSE;
if(++Nummer >2 && EingabeSchluss == FALSE)
{
Nummer = 0;
EingabeDaten_Auswertung(Index+DATENMAX-(++NeuDatenAkt),1);
Loesch_Str_Gadgets();
}
if(EingabeSchluss == FALSE)
ActivateGadget(&EingabeGadget[Nummer],MainWindow,NULL);
return(EingabeSchluss);
}
/*********************************************************************/
VOID EingabeDaten_Auswertung(Frei,VonWo)
INDEX *Frei;
USHORT VonWo;
{
VOID Loesch_Str_Gadgets();
static ULONG Dat;
static FLOAT Bet;
Set_Screen_Title(MAINWIND,WORKTITEL);
Dat = DatInLong(EingabeBuffer[0]); /* Datum umrechnen */
if(Dat < MINDATUM || Dat > MAXDATUM)
Dat = DatInLong(Datum());
Bet=(FLOAT)atof(EingabeBuffer[2]); /* Betrag umrechn. */
if(Bet > MAXFLOAT || Bet < MINFLOAT)
Bet = 0.0;
NeuSaldo += Bet;
if(VonWo)
{
ScrollRaster(Main_rp,0L,9L,10L,31L,610L,210L); /* Ausgabe in Wind */
PrintEintrag(Dat,EingabeBuffer[1],Bet,yUnt);
if(Frei->Datum != 1L) /* noch nie belegt */
Frei->Nummer = ++NeuVergeben;
} /* von der normalen Eingaberoutine */
Frei->Datum = Dat; /* Vorbereitung */
if
(!((Seek(HauptDatei,SIZEEINTRAG*(Frei->Nummer),OFFSET_BEGINNING) != DISKERROR)
&&(Write(HauptDatei,EingabeBuffer[1],34L) != DISKERROR)
&&(Write(HauptDatei,&Bet,4L) != DISKERROR)))
Disk_Fehler(MainWindow);
PrintNeuSaldo();
Geaendert = TRUE;
Loesch_Str_Gadgets();
Set_Screen_Title(MAINWIND,MAINTITEL);
return;
}
/*********************************************************************/
SHORT Aktiviere_Zeile(Zeile)
SHORT(Zeile);
{
VOID Zeichne_Border();
static SHORT BufferZeile = -1;
UCOUNT i;
if(BufferZeile < 0)
{
BufferZeile = Zeile;
Menu_Normal(AUS);
for(i=0;i<3;i++)
OffGadget(&ScrollGadget[i],MainWindow,NULL);
Zeichne_Border(Zeile,(UBYTE)RED);
}
else
{
if(Zeile == BufferZeile)
{
BufferZeile = -1;
Menu_Normal(AN);
for(i=0;i<3;i++)
OnGadget(&ScrollGadget[i],MainWindow,NULL);
Zeichne_Border(Zeile,(UBYTE)GREY);
}
}
return(BufferZeile);
}
/*********************************************************************/
VOID Zeichne_Border(Zeile,Farbe)
USHORT Zeile;
UBYTE Farbe;
{
WahlBorder.FrontPen = Farbe;
DrawBorder(Main_rp,&WahlBorder,8L,(LONG)(31+(Zeile*9)));
return;
}
/*********************************************************************/
VOID Off_Str_Gadgets()
{
register UCOUNT ir;
for(ir=0;ir<3;ir++)
OffGadget(&EingabeGadget[ir],MainWindow,NULL);
return;
}
/*********************************************************************/
VOID On_Str_Gadgets()
{
register UCOUNT ir;
for(ir=0;ir<3;ir++)
OnGadget(&EingabeGadget[ir],MainWindow,NULL);
LoeschFeld(Main_rp, 12L,225L,9);
LoeschFeld(Main_rp,108L,225L,34);
return;
}
/*********************************************************************/
VOID Loesch_Str_Gadgets()
{
*EingabeBuffer[0]=*EingabeBuffer[1]=*EingabeBuffer[2]='\0';
RefreshGadgets(MainWindow->FirstGadget,MainWindow,NULL);
return;
}
/*********************************************************************/
VOID Disk_Fehler(Window)
struct Window *Window;
{
USHORT DiskFehler = (USHORT)IoErr();
struct IntuiText *Help;
sprintf(TempText,"IoError Nr. %03u ",DiskFehler);
ReqText[7].IText = TempText;
Help = (Geaendert) ? &ReqText[9] : &ReqText[8];
if(!(Abfr_ReqGr(Window,Help,&ReqGad2,NULL)))
if((Geaendert) && (Window == MainWindow))
if(!(Abfr_ReqGr(Window,&ReqText[1],&ReqGad2,NULL)))
EndProgramm(DiskFehler);
return;
}
/*********************************************************************/
VOID PrintNachUnten()
{
register i;
if(AktIndex != MaxIndex)
{
Set_Screen_Title(MAINWIND,WORKTITEL);
AktIndex+=20;
if(AktIndex > MaxIndex) AktIndex=MaxIndex;
Lade_Seite(AktIndex);
for(i=0;i<20;i++)
{
ScrollRaster(Main_rp,0L,9L,10L,31L,610L,210L);
PrintEintrag
((AktIndex+i)->Datum,
(Eintrag+i)->Bezeichnung,
(Eintrag+i)->Betrag,
yUnt);
}
Set_Screen_Title(MAINWIND,MAINTITEL);
}
else Beep(MainScreen);
return;
}
/*********************************************************************/
VOID PrintNachOben()
{
register i;
INDEX *min = Index+DATENMAX-NeuDatenAkt;
if (AktIndex != min)
{
Set_Screen_Title(MAINWIND,WORKTITEL);
AktIndex-=20;
if(AktIndex < min) AktIndex=min;
Lade_Seite(AktIndex);
for(i=19;i>-1;i--)
{
ScrollRaster(Main_rp,0L,-9L,10L,31L,610L,210L);
PrintEintrag
((AktIndex+i)->Datum,
(Eintrag+i)->Bezeichnung,
(Eintrag+i)->Betrag,
yOben);
}
Set_Screen_Title(MAINWIND,MAINTITEL);
}
else Beep(MainScreen);
return;
}
/*********************************************************************/
VOID PrintUntereSeite()
{
AktIndex=Index+DATENMAX;
PrintNachUnten();
return;
}
/*********************************************************************/
VOID Print_And_Sort()
{
UCOUNT Zaehler;
Set_Screen_Title(MAINWIND,WORKTITEL);
Sort_Index();
if(++AktIndex > MaxIndex)
--AktIndex;
Lade_Seite(AktIndex);
Print_Seite();
Set_Screen_Title(MAINWIND,MAINTITEL);
return;
}
/*********************************************************************/
VOID Print_Seite()
{
REGISTER UCOUNT Zaehler;
for(Zaehler=0;Zaehler<20;Zaehler++)
{
LoeschFeld(Main_rp,xDatum,yOben+(Zaehler*9),75);
PrintEintrag((AktIndex+Zaehler)->Datum,
(Eintrag+Zaehler)->Bezeichnung,
(Eintrag+Zaehler)->Betrag,yOben+(Zaehler*9));
}
return;
}
/*********************************************************************/
VOID PrintNeuSaldo()
{
LoeschFeld(Main_rp,xPlus,248L,25);
Print(Main_rp,BetrInAsc(NeuSaldo),TAB(NeuSaldo),248L,FAR(NeuSaldo));
return;
}
/*********************************************************************/
VOID PrintEintrag(dat,bez,bet,pos)
long dat;
STRPTR bez;
float bet;
long pos;
{
Print(Main_rp,DatInAsc(dat),xDatum,pos,BLUE);
Print(Main_rp,bez,xBez,pos,BLUE);
Print(Main_rp,BetrInAsc(bet),TAB(bet),pos,FAR(bet));
return;
}
/*********************************************************************/
VOID Print(rp,text,x,y,far)
struct RastPort *rp;
STRPTR text;
long x,y,far;
{
SetAPen(rp,far);
Move(rp,x,y);
Text(rp,text,(LONG)strlen(text));
return;
}
/*********************************************************************/
VOID LoeschFeld(rp,x,y,len)
struct Rastport *rp;
ULONG x,y;
USHORT len;
{
SetAPen(rp,GREY);
RectFill(rp,x,y-6,x+(8*len),y+2);
return;
}
/*********************************************************************/
ULONG DatInLong(DatAsc)
STRPTR DatAsc;
{
STRPTR p;
ULONG DatLong = 0;
ULONG Mal = 10000L;
p=DatAsc+6;
while(p>=DatAsc)
{
DatLong+=(Mal*atol(p));
p-=3;
Mal/=100;
}
return(DatLong);
}
/*********************************************************************/
STRPTR DatInAsc(DatLong)
ULONG DatLong;
{
ULONG a=10000L;
ULONG b=100L;
ULONG c[3];
c[0]=DatLong/a;
c[1]=(DatLong-(c[0]*a))/b;
c[2]=DatLong-(c[0]*a)-(c[1]*b);
sprintf(TempText,"%02lu.%02lu.%02lu",c[2],c[1],c[0]);
return(TempText);
}
/*********************************************************************/
VOID Finde_Datum(AscDatum)
STRPTR AscDatum;
{
ULONG Datum = DatInLong(AscDatum);
if(Datum < MINDATUM) Datum = MINDATUM;
if(Datum > MAXDATUM) Datum = MAXDATUM;
AktIndex = Index;
while(AktIndex->Datum < Datum)
AktIndex++;
return;
}
/*********************************************************************/
VOID Setz_VonBis(IN)
INDEX *IN;
{
register UCOUNT i;
register USHORT x=155,y=240;
for(i=0;i<2;i++)
{
Print(Main_rp,DatInAsc(IN->Datum),(LONG)x,(LONG)y,BLACK);
y += 8;
IN += 19;
}
return;
}
/*********************************************************************/
STRPTR BetrInAsc(Saldo)
float Saldo;
{
sprintf(TempText,"%9.2f",Saldo);
return(TempText);
}
/*********************************************************************/
STRPTR Datum()
{
struct tm *Zeit;
long Z;
Z = time(NULL);
Zeit = localtime(&Z);
sprintf(TempText,"%02d.%02d.%02d",Zeit->tm_mday,(Zeit->tm_mon)+1,Zeit->tm_year);
return(TempText);
}
/*********************************************************************/
BOOL Sort_Index()
{
VOID Sort();
if(!(LG = (USHORT*)AllocMem(500L,MEMF_CLEAR)))
return(FALSE);
if(!(RG = (USHORT*)AllocMem(500L,MEMF_CLEAR)))
{
FreeMem(LG,500L);
return(FALSE);
}
LG[1]=0;
RG[1]=DATENMAX;
Sort();
FreeMem(RG,500L);
FreeMem(LG,500L);
return(TRUE);
}
VOID Sort()
{
VOID swapmem();
static ULONG vg;
static SHORT z,x,y;
z++;
if(LG[z] >= RG[z])
{
z--;
return;
}
x=LG[z];
y=RG[z];
vg=(Index+((x+y)/2))->Datum;
MARK:
if(x > y)
{
RG[z+1]=y;
LG[z+1]=LG[z];
Sort();
LG[z+1]=x;
RG[z+1]=RG[z];
Sort();
z--;
return;
}
while ((Index+x)->Datum < vg) x++;
while ((Index+y)->Datum > vg) y--;
if(x > y)
{
RG[z+1]=y;
LG[z+1]=LG[z];
Sort();
LG[z+1]=x;
RG[z+1]=RG[z];
Sort();
z--;
return;
}
swapmem((char*)(Index+y),(char*)(Index+x),6);
x++;
y--;
goto MARK;
}
/*********************************************************************/
VOID Menu_Normal(AnAus)
USHORT AnAus;
{
static USHORT Menus[] = {6, 2, 3, 4, 3, 2, 2};
UCOUNT i;
for(i=1;i<=Menus[0];i++)
Menu_Schalt(MainWindow,i-1,Menus[i],AnAus);
Menu_Schalt(MainWindow,2,4,(AnAus==AN) ? AUS : AN);
return;
}
/*********************************************************************/
VOID Menu_Saven(AnAus)
USHORT AnAus;
{
Menu_Schalt(MainWindow,1,2,AnAus);
return;
}
/*********************************************************************/
VOID Menu_Schalt(Window,MenuNr,ItemNr,An)
struct Window *Window;
USHORT MenuNr,ItemNr,An;
{
ULONG code = ItemNr*32+MenuNr;
if(An)
OnMenu(Window,code);
else
OffMenu(Window,code);
return;
}
/*********************************************************************/
VOID Set_Screen_Title(Wohin,Welchen)
USHORT Wohin;
USHORT Welchen;
{
struct Window *Window = (Wohin) ? NebenWindow : MainWindow;
static STRPTR Titel[3]={
(STRPTR)" -- GiroMan V3.00 Haupt © 1987/88 --",
(STRPTR)" -- GiroMan V3.00 Monat © 1988 --",
(STRPTR)" -- NICHT STÖREN, GIROMAN IST BESCHÄFTIGT --"};
SetWindowTitles(Window,FALSE,Titel[Welchen]);
return;
}
/*********************************************************************/
VOID Beep(Screen)
struct Screen *Screen;
{
int zaehler;
for (zaehler=1;zaehler<250;zaehler++)
DisplayBeep(Screen);
return;
}
/*********************************************************************/
VOID Lade_Seite(IN)
INDEX *IN;
{
VOID Stell_Prop();
UCOUNT i;
Setz_VonBis(IN);
Stell_Prop();
for(i=0;i<20;i++)
{
if(!((Seek(HauptDatei,IN->Nummer*SIZEEINTRAG,OFFSET_BEGINNING) != DISKERROR)
&&(Read(HauptDatei,Eintrag+i,SIZEEINTRAG) != DISKERROR)))
{
Disk_Fehler(MainWindow);
return;
break;
}
IN++;
}
return;
}
/*********************************************************************/
VOID Stell_Prop()
{
INDEX *min = Index+DATENMAX-NeuDatenAkt;
FLOAT GenauPosi;
ULONG NeuPosi;
NeuProp = (NeuDatenAkt > 20) ? 0xFFFF/((NeuDatenAkt)/20) : 0;
GenauPosi = ((AktIndex-min)/20.0)+0.999999;
NeuPosi = (ULONG)GenauPosi*NeuProp;
ModifyProp(ScrollGadget,MainWindow,NULL,PROPFLAGS,0L,NeuPosi,0L,(ULONG)NeuProp);
RefreshGadgets(ScrollGadget,MainWindow,NULL);
return;
}
/*********************************************************************/
VOID Mon_Auswert()
{
BOOL Wel_MonGadget();
VOID Mon_MausAbfrage();
BOOL Ende = FALSE;
while(!(Ende))
{
IDCMP_Abfrage(NebenWindow);
switch(MessClass)
{
case GADGETUP:
Ende = Wel_MonGadget();
break;
case MOUSEBUTTONS:
Mon_MausAbfrage();
break;
case REFRESHWINDOW:
Print_Monat(AktMonat);
break;
}
}
return;
}
/*********************************************************************/
BOOL Wel_MonGadget()
{
VOID Print_Monat();
VOID Eingabe_Monat();
VOID Loesch_Monat();
VOID Aender_Monat();
BOOL Save_MonDat();
BOOL Ende = FALSE;
if(!(MonEinSel))
{
switch(GadID)
{
case 30:
if(!(MonGeaendert))
Ende = TRUE;
else
if(Abfr_ReqGr(NebenWindow,&ReqText[21],&ReqGad2,NULL))
if(Save_MonDat())
Ende = TRUE;
break;
case 31:
AktMonat = (AktMonat == 11) ? 0 : AktMonat+1;
Print_Monat(AktMonat);
break;
case 32:
AktMonat = (AktMonat == 0) ? 11 : AktMonat-1;
Print_Monat(AktMonat);
break;
case 33:
if(MonGeaendert)
Save_MonDat();
break;
case 34:
Eingabe_Monat();
break;
}
}
else
{
switch(GadID)
{
case 35:
Aender_Monat();
break;
case 36:
Loesch_Monat();
break;
}
}
return(Ende);
}
/*********************************************************************/
VOID Eingabe_Monat()
{
SHORT Sprung;
BOOL Erfolg;
UCOUNT i;
UCOUNT j;
MONAT **Find_Pointer();
MONAT **Pointer;
MONAT *mon;
FLOAT saldo;
*(MonatBuffer[0]) = *(MonatBuffer[1]) = *(MonatBuffer[2]) = '\0';
if((Abfr_ReqGr(NebenWindow,NULL,&MonStrGad[2],&MonStrGad[0]))
&&(*(MonatBuffer[1]) != '\0')
&&(*(MonatBuffer[2]) != '\0')
&&((saldo=(FLOAT)atof(MonatBuffer[2])) <= MAXFLOAT)
&&(saldo >= MINFLOAT))
{
Sprung = (SHORT)-(atol(MonatBuffer[0]));
if((Sprung < 1) || (Sprung == 5) || (Sprung > 6))
Sprung = 12;
Pointer = Find_Pointer(Sprung);
for(i=0;i<(12/Sprung);i++)
{
mon = *(Pointer+i);
Erfolg = FALSE;
for(j=0;j<MONEINT;j++,mon++)
{
if(*((mon)->Bezeichnung) == '\0')
{
strcpy((mon)->Bezeichnung,MonatBuffer[1]);
(mon)->Betrag = saldo;
Erfolg = TRUE;
break;
}
}
if(!(Erfolg))
Abfr_ReqGr(NebenWindow,&ReqText[23],&ReqGad1,NULL);
}
MonGeaendert = TRUE;
}
return;
}
/*********************************************************************/
VOID Aender_Monat()
{
VOID Aktiviere_MonZeile();
MONAT **Find_Pointer();
MONAT **Pointer;
MONAT *mon;
SHORT Sprung;
SHORT i;
SHORT j;
MONAT *aktmon = Monat+((AktMonat*MONEINT)+AktMonZeile);
FLOAT saldo;
Aktiviere_MonZeile(AktMonZeile);
strcpy(MonatBuffer[0],All);
strcpy(MonatBuffer[1],aktmon->Bezeichnung);
sprintf(MonatBuffer[2],"%9.2f",aktmon->Betrag);
if((Abfr_ReqGr(NebenWindow,NULL,&MonStrGad[2],&MonStrGad[0]))
&&(*(MonatBuffer[1]) != '\0')
&&(*(MonatBuffer[2]) != '\0')
&&((saldo=(FLOAT)atof(MonatBuffer[2])) <= MAXFLOAT)
&&(saldo >= MINFLOAT))
{
Sprung = (strncmp(MonatBuffer[0],All,5)) ? 12 : 1;
Pointer = Find_Pointer(Sprung);
for(i=(Sprung==12)?0:11;i>-1;i--)
{
mon = *(Pointer+i);
for(j=0;j<MONEINT;j++,mon++)
{
if(*((mon)->Bezeichnung) == '\0')
break;
if((!strcmp((mon)->Bezeichnung,aktmon->Bezeichnung))
&&((mon)->Betrag == aktmon->Betrag))
{
strcpy((mon)->Bezeichnung,MonatBuffer[1]);
(mon)->Betrag = saldo;
break;
}
}
}
MonGeaendert = TRUE;
}
return;
}
/*********************************************************************/
VOID Loesch_Monat()
{
VOID Aktiviere_MonZeile();
VOID Aktiviere_MonZeile();
MONAT **Find_Pointer();
MONAT **Pointer;
MONAT *mon;
SHORT Sprung;
SHORT i;
SHORT j;
MONAT *aktmon = Monat+((AktMonat*MONEINT)+AktMonZeile);
Aktiviere_MonZeile(AktMonZeile);
strcpy(MonatBuffer[0],All);
if((Abfr_ReqGr(NebenWindow,&ReqText[24],&MonStrGad[0],&MonStrGad[0])))
{
Sprung = (strncmp(MonatBuffer[0],All,5)) ? 12 : 1;
Pointer = Find_Pointer(Sprung);
for(i=(Sprung==12)?0:11;i>-1;i--)
{
mon = *(Pointer+i);
for(j=0;j<MONEINT;j++)
{
if((!strcmp((mon+j)->Bezeichnung,aktmon->Bezeichnung))
&&((mon+j)->Betrag == aktmon->Betrag))
{
*((mon+j)->Bezeichnung) = '\0';
while((++j < MONEINT) && (*((mon+j)->Bezeichnung) != '\0'))
{
strcpy((mon+j-1)->Bezeichnung,(mon+j)->Bezeichnung);
(mon+j-1)->Betrag = (mon+j)->Betrag;
*((mon+j)->Bezeichnung) = '\0';
}
}
}
}
MonGeaendert = TRUE;
}
return;
}
/*********************************************************************/
BOOL Save_MonDat()
{
BOOL Ok = FALSE;
struct FileHandle *MonatDatei;
Set_Screen_Title(MONAWIND,WORKTITEL);
if(!((MonatDatei = Open(MonatName,MODE_NEWFILE))
&&(Write(MonatDatei,Monat,JAHRLENG) != DISKERROR)))
Disk_Fehler(NebenWindow);
else
{
MonGeaendert = FALSE;
Ok = TRUE;
}
if(MonatDatei)
Close(MonatDatei);
Set_Screen_Title(MONAWIND,MONATITEL);
return(Ok);
}
/*********************************************************************/
VOID Mon_MausAbfrage()
{
VOID Aktiviere_MonZeile();
if(MessCode != SELECTUP)
if(!(NebenWindow->MouseX < 11
|| NebenWindow->MouseX > 503
|| NebenWindow->MouseY < 35
|| NebenWindow->MouseY > 34+(AnzMonEin*9)))
Aktiviere_MonZeile((NebenWindow->MouseY-35)/9);
return;
}
/*********************************************************************/
VOID Aktiviere_MonZeile(TempZeile)
SHORT TempZeile;
{
if(!(MonEinSel))
{
AktMonZeile = ((NebenWindow->MouseY)-35)/9;
MonEinSel = TRUE;
}
else
{
if(AktMonZeile == TempZeile)
MonEinSel = FALSE;
}
MonWahlBor.FrontPen = (MonEinSel) ? (UBYTE)RED : (UBYTE)GREY;
DrawBorder(Neben_rp,&MonWahlBor,9L,(LONG)33+(AktMonZeile*9));
return;
}
/*********************************************************************/
BOOL Open_MonGraphs()
{
BOOL Ok;
Window2.Screen = MainScreen;
if((Monat = (MONAT *) AllocMem(JAHRLENG,MEMF_PUBLIC|MEMF_CLEAR))
&&(NebenWindow = (struct Window*) OpenWindow(&Window2)))
{
Ok = TRUE;
Set_Screen_Title(MONAWIND,MONATITEL);
Neben_rp = NebenWindow->RPort;
PolyDraw(Neben_rp,16L,RandNWind);
PrintIText(Neben_rp,&UeberN,0L,0L);
}
else
{
Abfr_ReqGr(MainWindow,&ReqText[13],&ReqGad1,NULL);
Ok = FALSE;
}
return(Ok);
}
/*********************************************************************/
BOOL Open_MonatDat()
{
BOOL Ok = TRUE;
struct FileHandle *MonatDatei;
MonGeaendert = FALSE;
Set_Screen_Title(MONAWIND,WORKTITEL);
if(!((MonatDatei = Open(MonatName,MODE_READWRITE))
&&(Read(MonatDatei,Monat,JAHRLENG) != DISKERROR)))
{
Ok = FALSE;
Disk_Fehler(NebenWindow);
}
if(MonatDatei)
Close(MonatDatei);
Set_Screen_Title(MONAWIND,MONATITEL);
return(Ok);
}
/*********************************************************************/
VOID Print_Monat(Welchen)
USHORT Welchen;
{
MONAT *mon = Monat+(Welchen*MONEINT);
STRPTR dat = Datum();
AnzMonEin = 0;
SetAPen(Neben_rp,GREY);
RectFill(Neben_rp,7L,28L,503L,227L);
LoeschFeld(Neben_rp,588L,22L,3);
Print(Neben_rp,&NameMonat[Welchen][0],588L,22L,RED);
while((*(mon->Bezeichnung) != '\0') && (AnzMonEin < MONEINT))
{
sprintf(TempTextGr,"01.%02u.%2s %-33s %9.2f",
Welchen+1,(dat+6),mon,mon->Betrag);
Print(Neben_rp,TempTextGr,xDatum,(LONG)40+(9*AnzMonEin),BLUE);
mon++;
AnzMonEin++;
}
return;
}
/*********************************************************************/
MONAT** Find_Pointer(Sprung)
SHORT Sprung;
{
UCOUNT i;
USHORT j = AktMonat;
static MONAT *MonPoint[12];
for(i=0;i<(12/Sprung);i++,j+=Sprung)
{
if(j > 11)
j-=12;
MonPoint[i] = Monat+(MONEINT*j);
}
return(&MonPoint[0]);
}
/*********************************************************************/
VOID End_Monat()
{
if(Monat)
FreeMem(Monat,JAHRLENG);
if(NebenWindow)
CloseWindow(NebenWindow);
return;
}
/*********************************************************************/
VOID EndProgramm(Fehler)
int Fehler;
{
UCOUNT i;
if ((Fehler) && (IntuitionBase) && (TempText))
{
sprintf(TempText,"GiroManager FATAL-ERROR: %03d",Fehler);
End.IText=TempText;
AutoRequest(NULL,&End,&Cancel,&Cancel,NULL,NULL,274L,60L);
}
if(HauptDatei) Close(HauptDatei);
if(Index) FreeMem(Index,INDEXLENG);
if(Eintrag) FreeMem(Eintrag,SIZEEINTRAG*20);
if(UndoBuffer) FreeMem(UndoBuffer,50L);
if(TempText) FreeMem(TempText,50L);
if(TempTextGr) FreeMem(TempTextGr,100L);
for(i=0;i<3;i++)
if(EingabeBuffer[i])
FreeMem(EingabeBuffer[i],34L);
for(i=0;i<3;i++)
if(SuchBuffer[i])
FreeMem(SuchBuffer[i],34L);
for(i=0;i<3;i++)
if(MonatBuffer[i])
FreeMem(MonatBuffer[i],34L);
if(MainWindow)
{
ClearMenuStrip(MainWindow);
CloseWindow(MainWindow);
}
if(MainScreen) CloseScreen(MainScreen);
if(GfxBase) CloseLibrary(GfxBase);
if(IntuitionBase) CloseLibrary(IntuitionBase);
exit(Fehler);
}
/*********************************************************************/
/*********************************************************************/
/*********************************************************************/